export default {
  namespaced: true,
  state: {
    // 当前播放的音乐
    currentMusic: null,
    // 播放状态
    isPlaying: false,
    // 是否正在等待播放（音频加载中）
    isPendingPlay: false,
    // 当前播放时间（秒）
    currentTime: 0,
    // 音乐总时长（秒）
    duration: 0,
    // 音量 (0-1)
    volume: 0.7,
    // 是否静音
    isMuted: false,
    // 播放模式 (normal, repeat-all, repeat-one, shuffle)
    playMode: 'normal',
    // 是否开启随机播放
    isShuffle: false,
    // 播放列表
    playlist: [],
    // 当前播放索引
    currentIndex: -1,
    // 是否显示播放器 - 改为始终显示
    showPlayer: true,
    // 收藏列表 (存储音乐ID)
    favorites: []
  },
  
  getters: {
    // 格式化当前时间
    formattedCurrentTime: (state) => {
      const numSeconds = Number(state.currentTime)
      if (isNaN(numSeconds) || numSeconds < 0) return '0:00'
      
      const minutes = Math.floor(numSeconds / 60)
      const seconds = Math.floor(numSeconds % 60)
      
      if (minutes >= 60) {
        const hours = Math.floor(minutes / 60)
        const remainingMinutes = minutes % 60
        return `${hours}:${remainingMinutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`
      } else {
        return `${minutes}:${seconds.toString().padStart(2, '0')}`
      }
    },
    
    // 格式化总时长
    formattedDuration: (state) => {
      const numSeconds = Number(state.duration)
      if (isNaN(numSeconds) || numSeconds <= 0) return '0:00'
      
      const minutes = Math.floor(numSeconds / 60)
      const seconds = Math.floor(numSeconds % 60)
      
      if (minutes >= 60) {
        const hours = Math.floor(minutes / 60)
        const remainingMinutes = minutes % 60
        return `${hours}:${remainingMinutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`
      } else {
        return `${minutes}:${seconds.toString().padStart(2, '0')}`
      }
    },
    
    // 播放进度百分比
    progress: (state) => {
      if (state.duration === 0) return 0
      return (state.currentTime / state.duration) * 100
    },
    
    // 是否有上一首
    hasPrevious: (state) => {
      if (state.playlist.length === 0) return false
      if (state.isShuffle) return state.playlist.length > 1
      return state.currentIndex > 0 || state.playMode === 'repeat-all'
    },
    
    // 是否有下一首
    hasNext: (state) => {
      if (state.playlist.length === 0) return false
      if (state.isShuffle) return state.playlist.length > 1
      return state.currentIndex < state.playlist.length - 1 || state.playMode === 'repeat-all'
    },
    
    // 当前播放的音乐是否已收藏
    isCurrentMusicFavorited: (state) => {
      if (!state.currentMusic) return false
      const musicId = state.currentMusic.musicId || state.currentMusic.id
      return state.favorites.includes(musicId)
    },
    
    // 收藏列表 getter
    favorites: (state) => state.favorites
  },
  
  mutations: {
    // 设置当前音乐
    SET_CURRENT_MUSIC(state, music) {
      state.currentMusic = music
      state.duration = music.duration || 0
    },
    
    // 设置播放状态
    SET_PLAYING(state, isPlaying) {
      state.isPlaying = isPlaying
      // 如果开始播放，清除等待状态
      if (isPlaying) {
        state.isPendingPlay = false
      }
    },
    
    // 设置等待播放状态
    SET_PENDING_PLAY(state, isPending) {
      state.isPendingPlay = isPending
    },
    
    // 设置当前时间
    SET_CURRENT_TIME(state, time) {
      state.currentTime = time
    },
    
    // 设置总时长
    SET_DURATION(state, duration) {
      state.duration = duration
    },
    
    // 设置音量
    SET_VOLUME(state, volume) {
      state.volume = Math.max(0, Math.min(1, volume))
      state.isMuted = state.volume === 0
    },
    
    // 设置静音状态
    SET_MUTED(state, isMuted) {
      state.isMuted = isMuted
    },
    
    // 设置播放模式
    SET_PLAY_MODE(state, mode) {
      state.playMode = mode
    },
    
    // 设置随机播放
    SET_SHUFFLE(state, isShuffle) {
      state.isShuffle = isShuffle
    },
    
    // 设置播放列表
    SET_PLAYLIST(state, playlist) {
      state.playlist = playlist
    },
    
    // 设置当前播放索引
    SET_CURRENT_INDEX(state, index) {
      state.currentIndex = index
    },
    
    // 显示/隐藏播放器
    SET_SHOW_PLAYER(state, show) {
      state.showPlayer = show
    },
    
    // 设置收藏列表
    SET_FAVORITES(state, favorites) {
      state.favorites = favorites
    },
    
    // 添加收藏
    ADD_FAVORITE(state, musicId) {
      if (!state.favorites.includes(musicId)) {
        state.favorites.push(musicId)
      }
    },
    
    // 移除收藏
    REMOVE_FAVORITE(state, musicId) {
      const index = state.favorites.indexOf(musicId)
      if (index > -1) {
        state.favorites.splice(index, 1)
      }
    }
  },
  
  actions: {
    // 播放音乐
    async playMusic({ commit, state }, music) {
      try {
        console.log('Vuex播放音乐:', music.title || music.name)
        
        // 设置当前音乐
        commit('SET_CURRENT_MUSIC', music)
        
        // 查找音乐在当前播放列表中的位置
        const musicId = music.musicId || music.id
        const existingIndex = state.playlist.findIndex(item => 
          (item.musicId || item.id) === musicId
        )
        
        if (existingIndex !== -1) {
          // 音乐已在播放列表中，设置当前索引
          commit('SET_CURRENT_INDEX', existingIndex)
          console.log('音乐已在播放列表中，索引:', existingIndex)
        } else {
          // 音乐不在播放列表中，添加到播放列表
          const newPlaylist = [...state.playlist, music]
          commit('SET_PLAYLIST', newPlaylist)
          commit('SET_CURRENT_INDEX', newPlaylist.length - 1)
          console.log('添加音乐到播放列表，新索引:', newPlaylist.length - 1)
        }
        
        // 显示播放器
        commit('SET_SHOW_PLAYER', true)
        
        // 直接设置播放状态为true
        commit('SET_PLAYING', true)
        
        console.log('当前播放列表长度:', state.playlist.length)
        console.log('当前播放索引:', state.currentIndex)
        
        // 如果用户已登录，记录播放历史（异步，不阻塞播放）
        this.dispatch('player/recordPlayHistory', music)
        
      } catch (error) {
        console.error('Vuex播放音乐失败:', error)
      }
    },
    
    // 设置播放列表
    setPlaylist({ commit }, playlist) {
      commit('SET_PLAYLIST', playlist)
    },
    
    // 记录播放历史（仅登录用户）
    async recordPlayHistory({ commit }, music) {
      try {
        const userToken = localStorage.getItem('userToken')
        const userExpiry = localStorage.getItem('userTokenExpiry')
        
        // 只有已登录的普通用户才记录播放历史
        if (!userToken || userToken === 'null' || userToken === '' || !userExpiry || Date.now() > parseInt(userExpiry)) {
          console.log('前台用户未登录或token过期，跳过播放历史记录')
          return
        }
        
        const { playlistAPI } = await import('@/utils/api')
        const musicId = music.musicId || music.id
        
        if (musicId) {
          await playlistAPI.addPlayHistory(musicId)
          console.log('已记录播放历史:', music.title || music.name)
        }
      } catch (error) {
        console.warn('记录播放历史失败:', error)
        // 如果是401/403错误，清除用户token
        if (error.response?.status === 401 || error.response?.status === 403) {
          localStorage.removeItem('userToken')
          localStorage.removeItem('userInfo')
          localStorage.removeItem('userTokenExpiry')
        }
      }
    },
    
    // 暂停/恢复播放
    togglePlay({ commit, state }) {
      commit('SET_PLAYING', !state.isPlaying)
    },
    
    // 停止播放
    stop({ commit }) {
      commit('SET_PLAYING', false)
      commit('SET_CURRENT_TIME', 0)
    },
    
    // 跳转到指定时间
    seek({ commit }, time) {
      commit('SET_CURRENT_TIME', time)
    },
    
    // 设置音量
    setVolume({ commit }, volume) {
      commit('SET_VOLUME', volume)
    },
    
    // 切换静音
    toggleMute({ commit, state }) {
      commit('SET_MUTED', !state.isMuted)
    },
    
    // 上一首
    previous({ commit, state, dispatch }) {
      if (state.playlist.length === 0) return
      
      if (state.isShuffle) {
        // 随机播放模式：随机选择一首（不包括当前）
        if (state.playlist.length > 1) {
          let randomIndex
          do {
            randomIndex = Math.floor(Math.random() * state.playlist.length)
          } while (randomIndex === state.currentIndex)
          const randomMusic = state.playlist[randomIndex]
          commit('SET_CURRENT_INDEX', randomIndex)
          dispatch('playMusic', randomMusic)
        }
      } else {
        // 正常模式
        let prevIndex = state.currentIndex - 1
        
        if (prevIndex < 0) {
          // 已经是第一首
          if (state.playMode === 'repeat-all') {
            // 循环模式：跳到最后一首
            prevIndex = state.playlist.length - 1
          } else {
            // 普通模式：不播放
            return
          }
        }
        
        const prevMusic = state.playlist[prevIndex]
        if (prevMusic) {
          commit('SET_CURRENT_INDEX', prevIndex)
          dispatch('playMusic', prevMusic)
        }
      }
    },
    
    // 下一首
    next({ commit, state, dispatch }) {
      if (state.playlist.length === 0) return
      
      if (state.isShuffle) {
        // 随机播放模式：随机选择一首（不包括当前）
        if (state.playlist.length > 1) {
          let randomIndex
          do {
            randomIndex = Math.floor(Math.random() * state.playlist.length)
          } while (randomIndex === state.currentIndex)
          const randomMusic = state.playlist[randomIndex]
          commit('SET_CURRENT_INDEX', randomIndex)
          dispatch('playMusic', randomMusic)
        }
      } else {
        // 正常模式
        let nextIndex = state.currentIndex + 1
        
        if (nextIndex >= state.playlist.length) {
          // 已经是最后一首
          if (state.playMode === 'repeat-all') {
            // 循环模式：回到第一首
            nextIndex = 0
          } else {
            // 普通模式：不播放
            return
          }
        }
        
        const nextMusic = state.playlist[nextIndex]
        if (nextMusic) {
          commit('SET_CURRENT_INDEX', nextIndex)
          dispatch('playMusic', nextMusic)
        }
      }
    },
    
    // 切换播放模式
    togglePlayMode({ commit, state }) {
      const modes = ['normal', 'repeat-all', 'repeat-one']
      const currentModeIndex = modes.indexOf(state.playMode)
      const nextMode = modes[(currentModeIndex + 1) % modes.length]
      commit('SET_PLAY_MODE', nextMode)
    },
    
    // 切换随机播放
    toggleShuffle({ commit, state }) {
      commit('SET_SHUFFLE', !state.isShuffle)
    },
    
    // 更新播放时间
    updateTime({ commit }, time) {
      commit('SET_CURRENT_TIME', time)
    },
    
    // 音乐播放结束
    onEnded({ state, dispatch, commit }) {
      // 随机播放优先处理
      if (state.isShuffle && state.playlist.length > 1) {
        let randomIndex
        do {
          randomIndex = Math.floor(Math.random() * state.playlist.length)
        } while (randomIndex === state.currentIndex)
        const randomMusic = state.playlist[randomIndex]
        commit('SET_CURRENT_INDEX', randomIndex)
        dispatch('playMusic', randomMusic)
        return
      }
      
      // 处理重复播放模式
      switch (state.playMode) {
        case 'repeat-one':
          // 重复播放当前歌曲
          dispatch('playMusic', state.currentMusic)
          break
        case 'repeat-all':
          // 重复播放列表：如果是最后一首，回到第一首；否则播放下一首
          if (state.currentIndex >= state.playlist.length - 1) {
            const firstMusic = state.playlist[0]
            if (firstMusic) {
              commit('SET_CURRENT_INDEX', 0)
              dispatch('playMusic', firstMusic)
            }
          } else {
            dispatch('next')
          }
          break
        default:
          // 正常模式，播放下一首
          if (state.currentIndex < state.playlist.length - 1) {
            dispatch('next')
          } else {
            // 播放列表结束，停止播放
            dispatch('stop')
          }
      }
    },
    
    // 加载收藏列表（仅登录用户）
    async loadFavorites({ commit }) {
      try {
        const userToken = localStorage.getItem('userToken')
        const userExpiry = localStorage.getItem('userTokenExpiry')
        
        // 只有已登录的普通用户才加载收藏列表
        if (!userToken || userToken === 'null' || userToken === '' || userToken.length <= 20 || !userExpiry || Date.now() > parseInt(userExpiry)) {
          console.log('前台用户未登录、token无效或过期，清空收藏列表')
          commit('SET_FAVORITES', [])
          return
        }
        
        const { playlistAPI } = await import('@/utils/api')
        const response = await playlistAPI.getFavorites(0, 1000)
        if (response.success && response.favorites) {
          const favoriteIds = response.favorites.map(item => item.music.musicId)
          commit('SET_FAVORITES', favoriteIds)
          console.log('已加载收藏列表:', favoriteIds.length, '首')
        } else if (!response.success && response.message && response.message.includes('认证失败')) {
          // Token已过期或无效，但不要立即清除，让用户手动重新登录
          console.warn('用户Token认证失败，但保留登录状态')
          commit('SET_FAVORITES', [])
          
          // 通知用户重新登录
          if (window.app && window.app.showToast) {
            window.app.showToast('收藏列表加载失败，可能需要重新登录', 'warning')
          }
        }
      } catch (error) {
        console.error('加载收藏列表失败:', error)
        
        // 网络错误不清理登录状态
        if (error.message && error.message.includes('Network Error')) {
          console.warn('网络错误，保留登录状态')
          commit('SET_FAVORITES', [])
          return
        }
        
        // 即使是401错误，也只清空收藏列表，保留登录状态
        console.warn('收藏列表加载失败，但保留登录状态')
        commit('SET_FAVORITES', [])
      }
    },
    
    // 切换收藏状态（仅登录用户）
    async toggleFavorite({ commit, state, dispatch }, musicData = null) {
      try {
        // 使用传入的音乐数据或当前播放的音乐
        const targetMusic = musicData || state.currentMusic
        
        if (!targetMusic) {
          console.warn('没有指定的音乐或当前播放的音乐')
          return
        }
        
        const userToken = localStorage.getItem('userToken')
        const userExpiry = localStorage.getItem('userTokenExpiry')
        
        // 检查用户登录状态
        if (!userToken || userToken === 'null' || userToken === '' || userToken.length <= 20 || !userExpiry || Date.now() > parseInt(userExpiry)) {
          // 通过root实例显示提示消息
          if (window.app && window.app.$root && window.app.$root.showToast) {
            window.app.$root.showToast('请先登录普通用户账号才能收藏音乐', 'warning')
          } else {
            alert('请先登录普通用户账号才能收藏音乐')
          }
          return
        }
        
        const { playlistAPI } = await import('@/utils/api')
        const musicId = targetMusic.musicId || targetMusic.id
        
        if (!musicId) {
          console.error('无法获取musicId，音乐对象:', targetMusic)
          if (window.app && window.app.$root && window.app.$root.showToast) {
            window.app.$root.showToast('收藏失败：无法获取音乐ID', 'error')
          }
          return
        }
        
        const isFavorited = state.favorites.includes(musicId)
        
        if (isFavorited) {
          // 取消收藏
          await playlistAPI.removeFavorite(musicId)
          commit('REMOVE_FAVORITE', musicId)
          console.log(`已取消收藏: ${targetMusic.title || targetMusic.name}`)
          if (window.app && window.app.$root && window.app.$root.showToast) {
            window.app.$root.showToast('已取消收藏', 'info')
          }
        } else {
          // 添加收藏
          await playlistAPI.addFavorite(musicId)
          commit('ADD_FAVORITE', musicId)
          console.log(`已添加收藏: ${targetMusic.title || targetMusic.name}`)
          if (window.app && window.app.$root && window.app.$root.showToast) {
            window.app.$root.showToast('已添加到我的喜欢', 'success')
          }
        }
        
      } catch (error) {
        console.error('收藏操作失败:', error)
        if (error.response?.status === 401 || error.response?.status === 403) {
          localStorage.removeItem('userToken')
          localStorage.removeItem('userInfo')
          localStorage.removeItem('userTokenExpiry')
          commit('SET_FAVORITES', [])
        }
        
        // 显示错误消息
        if (window.app && window.app.$root && window.app.$root.showToast) {
          window.app.$root.showToast('收藏操作失败，请重试', 'error')
        } else {
          alert('收藏操作失败，请重试')
        }
      }
    }
  }
} 